if (typeof Promise !== "undefined" && !Promise.prototype.finally) {
  Promise.prototype.finally = function(callback) {
    const promise = this.constructor;
    return this.then(
      (value) => promise.resolve(callback()).then(() => value),
      (reason) => promise.resolve(callback()).then(() => {
        throw reason;
      })
    );
  };
}
;
if (typeof uni !== "undefined" && uni && uni.requireGlobal) {
  const global = uni.requireGlobal();
  ArrayBuffer = global.ArrayBuffer;
  Int8Array = global.Int8Array;
  Uint8Array = global.Uint8Array;
  Uint8ClampedArray = global.Uint8ClampedArray;
  Int16Array = global.Int16Array;
  Uint16Array = global.Uint16Array;
  Int32Array = global.Int32Array;
  Uint32Array = global.Uint32Array;
  Float32Array = global.Float32Array;
  Float64Array = global.Float64Array;
  BigInt64Array = global.BigInt64Array;
  BigUint64Array = global.BigUint64Array;
}
;
if (uni.restoreGlobal) {
  uni.restoreGlobal(Vue, weex, plus, setTimeout, clearTimeout, setInterval, clearInterval);
}
(function(vue) {
  "use strict";
  function initRuntimeSocket(hosts, port, id) {
    if (hosts == "" || port == "" || id == "")
      return Promise.resolve(null);
    return hosts.split(",").reduce((promise, host) => {
      return promise.then((socket) => {
        if (socket != null)
          return Promise.resolve(socket);
        return tryConnectSocket(host, port, id);
      });
    }, Promise.resolve(null));
  }
  const SOCKET_TIMEOUT = 500;
  function tryConnectSocket(host, port, id) {
    return new Promise((resolve, reject) => {
      const socket = uni.connectSocket({
        url: `ws://${host}:${port}/${id}`,
        multiple: true,
        // 支付宝小程序 是否开启多实例
        fail() {
          resolve(null);
        }
      });
      const timer = setTimeout(() => {
        socket.close({
          code: 1006,
          reason: "connect timeout"
        });
        resolve(null);
      }, SOCKET_TIMEOUT);
      socket.onOpen((e) => {
        clearTimeout(timer);
        resolve(socket);
      });
      socket.onClose((e) => {
        clearTimeout(timer);
        resolve(null);
      });
      socket.onError((e) => {
        clearTimeout(timer);
        resolve(null);
      });
    });
  }
  function formatMessage(type, args) {
    try {
      return {
        type,
        args: formatArgs(args)
      };
    } catch (e) {
    }
    return {
      type,
      args: []
    };
  }
  function formatArgs(args) {
    return args.map((arg) => formatArg(arg));
  }
  function formatArg(arg, depth = 0) {
    if (depth >= 7) {
      return {
        type: "object",
        value: "[Maximum depth reached]"
      };
    }
    const type = typeof arg;
    switch (type) {
      case "string":
        return formatString(arg);
      case "number":
        return formatNumber(arg);
      case "boolean":
        return formatBoolean(arg);
      case "object":
        return formatObject(arg, depth);
      case "undefined":
        return formatUndefined();
      case "function":
        return formatFunction(arg);
      case "symbol": {
        return formatSymbol(arg);
      }
      case "bigint":
        return formatBigInt(arg);
    }
  }
  function formatFunction(value) {
    return {
      type: "function",
      value: `function ${value.name}() {}`
    };
  }
  function formatUndefined() {
    return {
      type: "undefined"
    };
  }
  function formatBoolean(value) {
    return {
      type: "boolean",
      value: String(value)
    };
  }
  function formatNumber(value) {
    return {
      type: "number",
      value: String(value)
    };
  }
  function formatBigInt(value) {
    return {
      type: "bigint",
      value: String(value)
    };
  }
  function formatString(value) {
    return {
      type: "string",
      value
    };
  }
  function formatSymbol(value) {
    return {
      type: "symbol",
      value: value.description
    };
  }
  function formatObject(value, depth) {
    if (value === null) {
      return {
        type: "null"
      };
    }
    {
      if (isComponentPublicInstance(value)) {
        return formatComponentPublicInstance(value, depth);
      }
      if (isComponentInternalInstance(value)) {
        return formatComponentInternalInstance(value, depth);
      }
      if (isUniElement(value)) {
        return formatUniElement(value, depth);
      }
      if (isCSSStyleDeclaration(value)) {
        return formatCSSStyleDeclaration(value, depth);
      }
    }
    if (Array.isArray(value)) {
      return {
        type: "object",
        subType: "array",
        value: {
          properties: value.map((v, i) => formatArrayElement(v, i, depth + 1))
        }
      };
    }
    if (value instanceof Set) {
      return {
        type: "object",
        subType: "set",
        className: "Set",
        description: `Set(${value.size})`,
        value: {
          entries: Array.from(value).map((v) => formatSetEntry(v, depth + 1))
        }
      };
    }
    if (value instanceof Map) {
      return {
        type: "object",
        subType: "map",
        className: "Map",
        description: `Map(${value.size})`,
        value: {
          entries: Array.from(value.entries()).map((v) => formatMapEntry(v, depth + 1))
        }
      };
    }
    if (value instanceof Promise) {
      return {
        type: "object",
        subType: "promise",
        value: {
          properties: []
        }
      };
    }
    if (value instanceof RegExp) {
      return {
        type: "object",
        subType: "regexp",
        value: String(value),
        className: "Regexp"
      };
    }
    if (value instanceof Date) {
      return {
        type: "object",
        subType: "date",
        value: String(value),
        className: "Date"
      };
    }
    if (value instanceof Error) {
      return {
        type: "object",
        subType: "error",
        value: value.message || String(value),
        className: value.name || "Error"
      };
    }
    let className = void 0;
    {
      const constructor = value.constructor;
      if (constructor) {
        if (constructor.get$UTSMetadata$) {
          className = constructor.get$UTSMetadata$().name;
        }
      }
    }
    return {
      type: "object",
      className,
      value: {
        properties: Object.entries(value).map((entry) => formatObjectProperty(entry[0], entry[1], depth + 1))
      }
    };
  }
  function isComponentPublicInstance(value) {
    return value.$ && isComponentInternalInstance(value.$);
  }
  function isComponentInternalInstance(value) {
    return value.type && value.uid != null && value.appContext;
  }
  function formatComponentPublicInstance(value, depth) {
    return {
      type: "object",
      className: "ComponentPublicInstance",
      value: {
        properties: Object.entries(value.$.type).map(([name, value2]) => formatObjectProperty(name, value2, depth + 1))
      }
    };
  }
  function formatComponentInternalInstance(value, depth) {
    return {
      type: "object",
      className: "ComponentInternalInstance",
      value: {
        properties: Object.entries(value.type).map(([name, value2]) => formatObjectProperty(name, value2, depth + 1))
      }
    };
  }
  function isUniElement(value) {
    return value.style && value.tagName != null && value.nodeName != null;
  }
  function formatUniElement(value, depth) {
    return {
      type: "object",
      // 非 x 没有 UniElement 的概念
      // className: 'UniElement',
      value: {
        properties: Object.entries(value).filter(([name]) => [
          "id",
          "tagName",
          "nodeName",
          "dataset",
          "offsetTop",
          "offsetLeft",
          "style"
        ].includes(name)).map(([name, value2]) => formatObjectProperty(name, value2, depth + 1))
      }
    };
  }
  function isCSSStyleDeclaration(value) {
    return typeof value.getPropertyValue === "function" && typeof value.setProperty === "function" && value.$styles;
  }
  function formatCSSStyleDeclaration(style, depth) {
    return {
      type: "object",
      value: {
        properties: Object.entries(style.$styles).map(([name, value]) => formatObjectProperty(name, value, depth + 1))
      }
    };
  }
  function formatObjectProperty(name, value, depth) {
    const result = formatArg(value, depth);
    result.name = name;
    return result;
  }
  function formatArrayElement(value, index, depth) {
    const result = formatArg(value, depth);
    result.name = `${index}`;
    return result;
  }
  function formatSetEntry(value, depth) {
    return {
      value: formatArg(value, depth)
    };
  }
  function formatMapEntry(value, depth) {
    return {
      key: formatArg(value[0], depth),
      value: formatArg(value[1], depth)
    };
  }
  const CONSOLE_TYPES = ["log", "warn", "error", "info", "debug"];
  let sendConsole = null;
  const messageQueue = [];
  const messageExtra = {};
  function sendConsoleMessages(messages) {
    if (sendConsole == null) {
      messageQueue.push(...messages);
      return;
    }
    sendConsole(JSON.stringify(Object.assign({
      type: "console",
      data: messages
    }, messageExtra)));
  }
  function setSendConsole(value, extra = {}) {
    sendConsole = value;
    Object.assign(messageExtra, extra);
    if (value != null && messageQueue.length > 0) {
      const messages = messageQueue.slice();
      messageQueue.length = 0;
      sendConsoleMessages(messages);
    }
  }
  const originalConsole = /* @__PURE__ */ CONSOLE_TYPES.reduce((methods, type) => {
    methods[type] = console[type].bind(console);
    return methods;
  }, {});
  function rewriteConsole() {
    function wrapConsole(type) {
      return function(...args) {
        [...args];
        sendConsoleMessages([formatMessage(type, args)]);
      };
    }
    if (isConsoleWritable()) {
      CONSOLE_TYPES.forEach((type) => {
        console[type] = wrapConsole(type);
      });
      return function restoreConsole() {
        CONSOLE_TYPES.forEach((type) => {
          console[type] = originalConsole[type];
        });
      };
    } else {
      {
        if (typeof uni !== "undefined" && uni.__f__) {
          const oldLog = uni.__f__;
          if (oldLog) {
            uni.__f__ = function(...args) {
              const [type, filename, ...rest] = args;
              oldLog(type, "", ...rest);
              sendConsoleMessages([formatMessage(type, [...rest, filename])]);
            };
            return function restoreConsole() {
              uni.__f__ = oldLog;
            };
          }
        }
      }
    }
    return function restoreConsole() {
    };
  }
  function isConsoleWritable() {
    const value = console.log;
    const sym = Symbol();
    try {
      console.log = sym;
    } catch (ex) {
      return false;
    }
    const isWritable = console.log === sym;
    console.log = value;
    return isWritable;
  }
  let sendError = null;
  const errorQueue = /* @__PURE__ */ new Set();
  const errorExtra = {};
  function sendErrorMessages(errors) {
    if (sendError == null) {
      errors.forEach((error) => {
        errorQueue.add(error);
      });
      return;
    }
    const data = errors.map((err) => {
      const isPromiseRejection = err && "promise" in err && "reason" in err;
      const prefix = isPromiseRejection ? "UnhandledPromiseRejection: " : "";
      if (isPromiseRejection) {
        err = err.reason;
      }
      if (err instanceof Error && err.stack) {
        if (err.message && !err.stack.includes(err.message)) {
          return `${prefix}${err.message}
${err.stack}`;
        }
        return `${prefix}${err.stack}`;
      }
      if (typeof err === "object" && err !== null) {
        try {
          return prefix + JSON.stringify(err);
        } catch (err2) {
          return prefix + String(err2);
        }
      }
      return prefix + String(err);
    }).filter(Boolean);
    if (data.length > 0) {
      sendError(JSON.stringify(Object.assign({
        type: "error",
        data
      }, errorExtra)));
    }
  }
  function setSendError(value, extra = {}) {
    sendError = value;
    Object.assign(errorExtra, extra);
    if (value != null && errorQueue.size > 0) {
      const errors = Array.from(errorQueue);
      errorQueue.clear();
      sendErrorMessages(errors);
    }
  }
  function initOnError() {
    function onError(error) {
      try {
        if (typeof PromiseRejectionEvent !== "undefined" && error instanceof PromiseRejectionEvent && error.reason instanceof Error && error.reason.message && error.reason.message.includes(`Cannot create property 'errMsg' on string 'taskId`)) {
          return;
        }
        if (false)
          ;
        sendErrorMessages([error]);
      } catch (err) {
        originalConsole.error(err);
      }
    }
    if (typeof uni.onError === "function") {
      uni.onError(onError);
    }
    if (typeof uni.onUnhandledRejection === "function") {
      uni.onUnhandledRejection(onError);
    }
    return function offError() {
      if (typeof uni.offError === "function") {
        uni.offError(onError);
      }
      if (typeof uni.offUnhandledRejection === "function") {
        uni.offUnhandledRejection(onError);
      }
    };
  }
  function initRuntimeSocketService() {
    const hosts = "127.0.0.1,192.168.31.50";
    const port = "8090";
    const id = "app-harmony_b9WWgR";
    const lazy = typeof swan !== "undefined";
    let restoreError = lazy ? () => {
    } : initOnError();
    let restoreConsole = lazy ? () => {
    } : rewriteConsole();
    return Promise.resolve().then(() => {
      if (lazy) {
        restoreError = initOnError();
        restoreConsole = rewriteConsole();
      }
      return initRuntimeSocket(hosts, port, id).then((socket) => {
        if (!socket) {
          restoreError();
          restoreConsole();
          originalConsole.error(wrapError("开发模式下日志通道建立 socket 连接失败。"));
          originalConsole.error(wrapError("如果是小程序平台，请勾选不校验合法域名配置。"));
          originalConsole.error(wrapError("如果是运行到真机，请确认手机与电脑处于同一网络。"));
          return false;
        }
        initMiniProgramGlobalFlag();
        socket.onClose(() => {
          originalConsole.error(wrapError("开发模式下日志通道 socket 连接关闭，请在 HBuilderX 中重新运行。"));
          restoreError();
          restoreConsole();
        });
        setSendConsole((data) => {
          socket.send({
            data
          });
        });
        setSendError((data) => {
          socket.send({
            data
          });
        });
        return true;
      });
    });
  }
  const ERROR_CHAR = "‌";
  function wrapError(error) {
    return `${ERROR_CHAR}${error}${ERROR_CHAR}`;
  }
  function initMiniProgramGlobalFlag() {
    if (typeof wx !== "undefined") {
      wx.__uni_console__ = true;
    } else if (typeof my !== "undefined") {
      my.__uni_console__ = true;
    } else if (typeof tt !== "undefined") {
      tt.__uni_console__ = true;
    } else if (typeof swan !== "undefined") {
      swan.__uni_console__ = true;
    } else if (typeof qq !== "undefined") {
      qq.__uni_console__ = true;
    } else if (typeof ks !== "undefined") {
      ks.__uni_console__ = true;
    } else if (typeof jd !== "undefined") {
      jd.__uni_console__ = true;
    } else if (typeof xhs !== "undefined") {
      xhs.__uni_console__ = true;
    } else if (typeof has !== "undefined") {
      has.__uni_console__ = true;
    } else if (typeof qa !== "undefined") {
      qa.__uni_console__ = true;
    }
  }
  initRuntimeSocketService();
  function formatAppLog(type, filename, ...args) {
    if (uni.__log__) {
      uni.__log__(type, filename, ...args);
    } else {
      console[type].apply(console, [...args, filename]);
    }
  }
  const BASE_URL = "https://v3.alapi.cn/api";
  const TOKEN = "qlVquQZPYSeaCi6u";
  const getSolarTermsByYear = async (year) => {
    try {
      const response = await uni.request({
        url: `${BASE_URL}/solarTerm`,
        method: "GET",
        data: {
          token: TOKEN,
          year
        }
      });
      if (response.data.code === 200) {
        return response.data.data;
      } else {
        throw new Error(response.data.message || "获取节气数据失败");
      }
    } catch (error) {
      formatAppLog("error", "at api/solarTerm.js:23", "获取年度节气列表失败:", error);
      throw error;
    }
  };
  const getSolarTermByDate = async (date) => {
    try {
      const response = await uni.request({
        url: `${BASE_URL}/solarTerm/search`,
        method: "GET",
        data: {
          token: TOKEN,
          date
        }
      });
      if (response.data.code === 200) {
        return response.data.data;
      } else {
        throw new Error(response.data.message || "获取节气数据失败");
      }
    } catch (error) {
      formatAppLog("error", "at api/solarTerm.js:46", "获取节气信息失败:", error);
      throw error;
    }
  };
  const _export_sfc = (sfc, props) => {
    const target = sfc.__vccOpts || sfc;
    for (const [key, val] of props) {
      target[key] = val;
    }
    return target;
  };
  const _sfc_main$1 = {
    data() {
      return {
        currentYear: (/* @__PURE__ */ new Date()).getFullYear().toString(),
        searchDate: "",
        solarTerms: [],
        loading: false,
        error: "",
        showDetail: false,
        selectedTerm: null
      };
    },
    onLoad() {
      this.loadSolarTerms();
    },
    methods: {
      async loadSolarTerms() {
        this.loading = true;
        this.error = "";
        try {
          const data = await getSolarTermsByYear(this.currentYear);
          this.solarTerms = data;
        } catch (error) {
          this.error = error.message || "获取节气数据失败";
        } finally {
          this.loading = false;
        }
      },
      async searchByDate() {
        if (!this.searchDate) {
          uni.showToast({
            title: "请选择日期",
            icon: "none"
          });
          return;
        }
        this.loading = true;
        this.error = "";
        try {
          const data = await getSolarTermByDate(this.searchDate);
          if (data.exists) {
            this.showTermDetail(data);
          } else {
            uni.showToast({
              title: "该日期不是节气日",
              icon: "none"
            });
          }
        } catch (error) {
          uni.showToast({
            title: error.message || "查询失败",
            icon: "none"
          });
        } finally {
          this.loading = false;
        }
      },
      onYearChange(e) {
        this.currentYear = e.detail.value;
        this.loadSolarTerms();
      },
      onDateChange(e) {
        this.searchDate = e.detail.value;
      },
      showTermDetail(term) {
        this.selectedTerm = term;
        this.showDetail = true;
      },
      closeDetail() {
        this.showDetail = false;
        this.selectedTerm = null;
      }
    }
  };
  function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
    return vue.openBlock(), vue.createElementBlock("view", { class: "container" }, [
      vue.createElementVNode("view", { class: "header" }, [
        vue.createElementVNode("text", { class: "title" }, "二十四节气"),
        vue.createElementVNode("view", { class: "search-box" }, [
          vue.createElementVNode("picker", {
            mode: "date",
            value: $data.searchDate,
            start: "2000-01-01",
            end: "2100-12-31",
            onChange: _cache[0] || (_cache[0] = (...args) => $options.onDateChange && $options.onDateChange(...args))
          }, [
            vue.createElementVNode("view", { class: "picker" }, [
              vue.createElementVNode(
                "text",
                null,
                vue.toDisplayString($data.searchDate || "选择日期"),
                1
                /* TEXT */
              )
            ])
          ], 40, ["value"]),
          vue.createElementVNode("button", {
            class: "search-btn",
            onClick: _cache[1] || (_cache[1] = (...args) => $options.searchByDate && $options.searchByDate(...args))
          }, "查询")
        ]),
        vue.createElementVNode("view", { class: "year-selector" }, [
          vue.createElementVNode("picker", {
            mode: "date",
            fields: "year",
            value: $data.currentYear,
            start: "2000",
            end: "2100",
            onChange: _cache[2] || (_cache[2] = (...args) => $options.onYearChange && $options.onYearChange(...args))
          }, [
            vue.createElementVNode("view", { class: "picker" }, [
              vue.createElementVNode(
                "text",
                null,
                vue.toDisplayString($data.currentYear) + "年",
                1
                /* TEXT */
              )
            ])
          ], 40, ["value"])
        ])
      ]),
      vue.createElementVNode("scroll-view", {
        class: "solar-terms-list",
        "scroll-y": ""
      }, [
        $data.loading ? (vue.openBlock(), vue.createElementBlock("view", {
          key: 0,
          class: "loading"
        }, [
          vue.createElementVNode("text", null, "加载中...")
        ])) : $data.error ? (vue.openBlock(), vue.createElementBlock("view", {
          key: 1,
          class: "error"
        }, [
          vue.createElementVNode(
            "text",
            null,
            vue.toDisplayString($data.error),
            1
            /* TEXT */
          )
        ])) : (vue.openBlock(), vue.createElementBlock("view", { key: 2 }, [
          (vue.openBlock(true), vue.createElementBlock(
            vue.Fragment,
            null,
            vue.renderList($data.solarTerms, (term, index) => {
              return vue.openBlock(), vue.createElementBlock("view", {
                key: index,
                class: "term-item",
                onClick: ($event) => $options.showTermDetail(term)
              }, [
                vue.createElementVNode("view", { class: "term-header" }, [
                  vue.createElementVNode(
                    "text",
                    { class: "term-name" },
                    vue.toDisplayString(term.name),
                    1
                    /* TEXT */
                  ),
                  vue.createElementVNode(
                    "text",
                    { class: "term-date" },
                    vue.toDisplayString(term.date),
                    1
                    /* TEXT */
                  )
                ]),
                vue.createElementVNode(
                  "text",
                  { class: "term-meaning" },
                  vue.toDisplayString(term.meaning),
                  1
                  /* TEXT */
                )
              ], 8, ["onClick"]);
            }),
            128
            /* KEYED_FRAGMENT */
          ))
        ]))
      ]),
      vue.createCommentVNode(" 节气详情弹窗 "),
      $data.showDetail ? (vue.openBlock(), vue.createElementBlock("view", {
        key: 0,
        class: "detail-modal"
      }, [
        vue.createElementVNode("view", { class: "modal-content" }, [
          vue.createElementVNode("view", { class: "modal-header" }, [
            vue.createElementVNode(
              "text",
              { class: "modal-title" },
              vue.toDisplayString($data.selectedTerm.name),
              1
              /* TEXT */
            ),
            vue.createElementVNode("text", {
              class: "close-btn",
              onClick: _cache[3] || (_cache[3] = (...args) => $options.closeDetail && $options.closeDetail(...args))
            }, "×")
          ]),
          vue.createElementVNode("scroll-view", {
            class: "modal-body",
            "scroll-y": ""
          }, [
            vue.createElementVNode("view", { class: "detail-item" }, [
              vue.createElementVNode("text", { class: "detail-label" }, "日期："),
              vue.createElementVNode(
                "text",
                null,
                vue.toDisplayString($data.selectedTerm.date),
                1
                /* TEXT */
              )
            ]),
            vue.createElementVNode("view", { class: "detail-item" }, [
              vue.createElementVNode("text", { class: "detail-label" }, "时间："),
              vue.createElementVNode(
                "text",
                null,
                vue.toDisplayString($data.selectedTerm.time),
                1
                /* TEXT */
              )
            ]),
            vue.createElementVNode("view", { class: "detail-item" }, [
              vue.createElementVNode("text", { class: "detail-label" }, "气候："),
              vue.createElementVNode(
                "text",
                null,
                vue.toDisplayString($data.selectedTerm.climate),
                1
                /* TEXT */
              )
            ]),
            vue.createElementVNode("view", { class: "detail-item" }, [
              vue.createElementVNode("text", { class: "detail-label" }, "习俗："),
              vue.createElementVNode(
                "text",
                null,
                vue.toDisplayString($data.selectedTerm.xisu),
                1
                /* TEXT */
              )
            ]),
            vue.createElementVNode("view", { class: "detail-item" }, [
              vue.createElementVNode("text", { class: "detail-label" }, "描述："),
              vue.createElementVNode(
                "text",
                null,
                vue.toDisplayString($data.selectedTerm.desc),
                1
                /* TEXT */
              )
            ]),
            vue.createElementVNode("view", { class: "detail-item" }, [
              vue.createElementVNode("text", { class: "detail-label" }, "谚语："),
              vue.createElementVNode("view", { class: "proverb-list" }, [
                (vue.openBlock(true), vue.createElementBlock(
                  vue.Fragment,
                  null,
                  vue.renderList($data.selectedTerm.proverb, (proverb, index) => {
                    return vue.openBlock(), vue.createElementBlock(
                      "text",
                      {
                        key: index,
                        class: "proverb-item"
                      },
                      vue.toDisplayString(proverb),
                      1
                      /* TEXT */
                    );
                  }),
                  128
                  /* KEYED_FRAGMENT */
                ))
              ])
            ])
          ])
        ])
      ])) : vue.createCommentVNode("v-if", true)
    ]);
  }
  const PagesIndexIndex = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["render", _sfc_render], ["__file", "/Users/jianguo/Desktop/teaching/uni_flutter_solarterm/pages/index/index.vue"]]);
  __definePage("pages/index/index", PagesIndexIndex);
  const _sfc_main = {
    onLaunch: function() {
      formatAppLog("log", "at App.vue:4", "App Launch");
    },
    onShow: function() {
      formatAppLog("log", "at App.vue:7", "App Show");
    },
    onHide: function() {
      formatAppLog("log", "at App.vue:10", "App Hide");
    }
  };
  const App = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "/Users/jianguo/Desktop/teaching/uni_flutter_solarterm/App.vue"]]);
  function createApp() {
    const app = vue.createVueApp(App);
    return {
      app
    };
  }
  const { app: __app__, Vuex: __Vuex__, Pinia: __Pinia__ } = createApp();
  uni.Vuex = __Vuex__;
  uni.Pinia = __Pinia__;
  __app__.provide("__globalStyles", __uniConfig.styles);
  __app__._component.mpType = "app";
  __app__._component.render = () => {
  };
  __app__.mount("#app");
})(Vue);
